// utils/cageConfig.js

// 默认配置
const DEFAULT_CONFIG = {
  cageCount: 8,
  cageLayout: [1, 4, 2, 5, 3, 6, 7, 8], // 默认的鸽笼布局顺序
  lastUpdate: null,
  source: 'default'
};

// 配置键名
const CONFIG_KEY = 'cageConfig';

// 获取鸽笼配置
export const getCageConfig = async () => {
  try {
    const siteId = uni.getStorageSync('siteId');
    if (!siteId) {
      console.warn('未找到siteId，使用默认配置');
      return DEFAULT_CONFIG;
    }
    
    // 尝试从本地存储获取配置
    const configKey = `${CONFIG_KEY}_${siteId}`;
    const localConfig = uni.getStorageSync(configKey);
    
    if (localConfig && localConfig.cageCount) {
      console.log('从本地存储获取鸽笼配置:', localConfig.cageCount);
      return localConfig;
    }
    
    console.log('本地无配置，使用默认配置');
    return DEFAULT_CONFIG;
  } catch (error) {
    console.error('获取鸽笼配置失败:', error);
    return DEFAULT_CONFIG;
  }
};

// 设置鸽笼配置
export const setCageConfig = async (config) => {
  try {
    const siteId = uni.getStorageSync('siteId');
    if (!siteId) {
      console.error('未找到siteId，无法保存配置');
      return false;
    }
    
    // 验证配置
    if (!config || typeof config.cageCount !== 'number' || config.cageCount <= 0) {
      console.error('无效的鸽笼配置:', config);
      return false;
    }
    
    // 生成布局
    const cageLayout = generateCageLayout(config.cageCount);
    
    const newConfig = {
      ...DEFAULT_CONFIG,
      ...config,
      cageLayout: cageLayout,
      lastUpdate: new Date().getTime(),
      source: config.source || 'manual'
    };
    
    const configKey = `${CONFIG_KEY}_${siteId}`;
    uni.setStorageSync(configKey, newConfig);
    
    console.log('鸽笼配置保存成功:', newConfig.cageCount, '个鸽笼');
    
    // 触发全局事件通知其他组件
    if (typeof uni.$emit === 'function') {
      uni.$emit('cageConfigUpdated', newConfig);
    }
    
    return true;
  } catch (error) {
    console.error('保存鸽笼配置失败:', error);
    return false;
  }
};

// 从查蛋功能获取配置
export const fetchCageConfigFromStatu = async (statuData) => {
  try {
    if (!statuData || !Array.isArray(statuData)) {
      console.warn('无效的状态数据，无法获取鸽笼配置');
      return null;
    }
    
    // 根据状态数据计算鸽笼数量
    const cageCount = statuData.length;
    
    if (cageCount > 0) {
      const config = {
        cageCount: cageCount,
        source: 'statu_api'
      };
      
      const success = await setCageConfig(config);
      if (success) {
        console.log('从查蛋状态获取鸽笼配置成功:', cageCount, '个鸽笼');
        return config;
      }
    }
    
    return null;
  } catch (error) {
    console.error('从查蛋状态获取配置失败:', error);
    return null;
  }
};

// 生成鸽笼布局
const generateCageLayout = (cageCount) => {
  if (cageCount <= 6) {
    // 6个及以下使用固定布局
    const baseLayout = [1, 4, 2, 5, 3, 6];
    return baseLayout.slice(0, cageCount);
  }
  
  // 7个以上在基础布局上追加
  const baseLayout = [1, 4, 2, 5, 3, 6];
  const additionalCages = Array.from({length: cageCount - 6}, (_, i) => i + 7);
  return [...baseLayout, ...additionalCages];
};

// 获取鸽笼列表
export const getCageList = async () => {
  try {
    const config = await getCageConfig();
    return Array.from({length: config.cageCount}, (_, i) => i + 1);
  } catch (error) {
    console.error('获取鸽笼列表失败:', error);
    return Array.from({length: DEFAULT_CONFIG.cageCount}, (_, i) => i + 1);
  }
};

// 获取布局后的鸽笼列表
export const getLayoutCageList = async () => {
  try {
    const config = await getCageConfig();
    return config.cageLayout;
  } catch (error) {
    console.error('获取布局鸽笼列表失败:', error);
    return DEFAULT_CONFIG.cageLayout;
  }
};

// 重置为默认配置
export const resetCageConfig = async () => {
  try {
    const siteId = uni.getStorageSync('siteId');
    if (siteId) {
      const configKey = `${CONFIG_KEY}_${siteId}`;
      uni.removeStorageSync(configKey);
      console.log('鸽笼配置已重置为默认值');
      
      // 触发更新事件
      if (typeof uni.$emit === 'function') {
        uni.$emit('cageConfigUpdated', DEFAULT_CONFIG);
      }
    }
    return true;
  } catch (error) {
    console.error('重置配置失败:', error);
    return false;
  }
};

// 监听配置变化
export const onCageConfigChange = (callback) => {
  if (typeof callback !== 'function') {
    console.error('监听回调必须是一个函数');
    return;
  }
  
  // 使用uni-app的事件系统
  if (typeof uni.$on === 'function') {
    uni.$on('cageConfigUpdated', callback);
  } else {
    // 备用方案：定期检查
    console.warn('uni.$on不可用，使用定期检查');
    let lastConfig = null;
    
    const checkInterval = setInterval(async () => {
      try {
        const currentConfig = await getCageConfig();
        if (!lastConfig || currentConfig.lastUpdate !== lastConfig.lastUpdate) {
          callback(currentConfig);
          lastConfig = currentConfig;
        }
      } catch (error) {
        console.error('配置检查错误:', error);
      }
    }, 2000);
    
    // 返回清理函数
    return () => clearInterval(checkInterval);
  }
  
  // 返回清理函数
  return () => {
    if (typeof uni.$off === 'function') {
      uni.$off('cageConfigUpdated', callback);
    }
  };
};

// 验证配置是否有效
export const validateCageConfig = (config) => {
  if (!config || typeof config !== 'object') {
    return false;
  }
  
  if (typeof config.cageCount !== 'number' || config.cageCount <= 0 || config.cageCount > 100) {
    return false;
  }
  
  if (!Array.isArray(config.cageLayout) || config.cageLayout.length !== config.cageCount) {
    return false;
  }
  
  // 验证布局是否包含所有鸽笼编号
  const expectedNumbers = Array.from({length: config.cageCount}, (_, i) => i + 1);
  const sortedLayout = [...config.cageLayout].sort((a, b) => a - b);
  
  return JSON.stringify(sortedLayout) === JSON.stringify(expectedNumbers);
};

// 获取配置信息（调试用）
export const getConfigInfo = async () => {
  try {
    const config = await getCageConfig();
    return {
      cageCount: config.cageCount,
      layout: config.cageLayout,
      lastUpdate: config.lastUpdate,
      source: config.source,
      isValid: validateCageConfig(config)
    };
  } catch (error) {
    console.error('获取配置信息失败:', error);
    return null;
  }
};

export default {
  getCageConfig,
  setCageConfig,
  fetchCageConfigFromStatu,
  getCageList,
  getLayoutCageList,
  resetCageConfig,
  onCageConfigChange,
  validateCageConfig,
  getConfigInfo
};